// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command

// 云函数入口函数
exports.main = async (event, context) => {
  console.log('[login] 开始处理登录请求:', event);

  const wxContext = cloud.getWXContext()
  const openid = wxContext.OPENID;

  if (!openid) {
    console.error('[login] 无法获取用户openid');
    return {
      success: false,
      error: '无法获取用户身份信息'
    };
  }

  console.log('[login] 用户openid:', openid);

  try {
    // 查询用户是否已存在
    const userRes = await db.collection('users').where({
      openid: openid
    }).get();

    let userData = null;

    if (userRes.data.length === 0) {
      // 用户不存在，创建新用户
      console.log('[login] 新用户，创建用户记录');

      const userProfile = event.userInfo || {};

      // 处理nickName和nickname两种情况
      const userNickname = userProfile.nickName || userProfile.nickname || '用户' + openid.substring(openid.length - 6);

      // 准备用户数据
      const userDoc = {
        openid: openid,
        unionid: wxContext.UNIONID || '',
        nickname: userNickname,
        avatarUrl: userProfile.avatarUrl || '',
        gender: userProfile.gender || 0,
        level: '普通会员',
        points: 0,
        balance: 0,
        coupons: [],
        createTime: db.serverDate(),
        lastLoginTime: db.serverDate()
      };

      // 创建用户
      const createResult = await db.collection('users').add({
        data: userDoc
      });

      console.log('[login] 用户创建成功, _id:', createResult._id);

      // 获取完整创建的用户数据
      userData = {
        ...userDoc,
        _id: createResult._id
      };
    } else {
      // 用户存在，更新最后登录时间
      console.log('[login] 已存在用户，更新登录时间');

      userData = userRes.data[0];

      // 更新用户资料（如果有提供）和登录时间
      const updateData = {
        lastLoginTime: db.serverDate()
      };

      // 只更新用户昵称当明确要求更新时
      if (event.userInfo && event.forceUpdateProfile) {
        // 优先使用nickname（后端字段），然后是nickName（微信字段）
        const updatedNickname = event.userInfo.nickname || event.userInfo.nickName;
        if (updatedNickname) {
          console.log('[login] 强制更新用户昵称:', updatedNickname);
          updateData.nickname = updatedNickname;
        }

        if (event.userInfo.avatarUrl) updateData.avatarUrl = event.userInfo.avatarUrl;
        if (event.userInfo.gender) updateData.gender = event.userInfo.gender;
      }

      await db.collection('users').doc(userData._id).update({
        data: updateData
      });

      // 如果是强制更新模式，并且有提供新昵称，则更新内存中的用户数据
      if (event.userInfo && event.forceUpdateProfile) {
        const updatedNickname = event.userInfo.nickname || event.userInfo.nickName;
        if (updatedNickname) {
          userData.nickname = updatedNickname;
        }
        if (event.userInfo.avatarUrl) userData.avatarUrl = event.userInfo.avatarUrl;
        if (event.userInfo.gender) userData.gender = event.userInfo.gender;
      }
      userData.lastLoginTime = new Date();
    }

    // 同步本地购物车到云端
    if (event.cartItems && Array.isArray(event.cartItems)) {
      await syncCartItems(openid, event.cartItems);
    }

    return {
      success: true,
      openid: openid,
      appid: wxContext.APPID,
      unionid: wxContext.UNIONID || '',
      userData: userData
    };
  } catch (error) {
    console.error('[login] 处理登录异常:', error);
    return {
      success: false,
      error: error.message || '登录处理失败'
    };
  }
}

/**
 * 同步购物车数据
 * @param {string} openid - 用户openid
 * @param {Array} localItems - 本地购物车商品
 */
async function syncCartItems(openid, localItems) {
  try {
    console.log('[login] 开始同步购物车数据');

    // 获取云端购物车数据
    const cartRes = await db.collection('cart').where({
      openid: openid
    }).get();

    if (cartRes.data.length > 0) {
      // 已有购物车数据，进行合并
      const cartId = cartRes.data[0]._id;
      const cloudItems = cartRes.data[0].items || [];

      console.log('[login] 云端已有购物车数据，项目数:', cloudItems.length);

      // 简单合并策略：如果本地有数据，则合并到云端
      if (localItems && localItems.length > 0) {
        console.log('[login] 本地购物车有数据，项目数:', localItems.length);

        // 合并购物车（这里采用简单策略：同ID商品以本地为准）
        const mergedItems = mergeCartItems(cloudItems, localItems);

        // 更新到云端
        await db.collection('cart').doc(cartId).update({
          data: {
            items: mergedItems,
            updateTime: db.serverDate()
          }
        });

        console.log('[login] 合并后购物车项目数:', mergedItems.length);
      }
    } else if (localItems && localItems.length > 0) {
      // 没有云端购物车，但有本地数据，创建新购物车
      console.log('[login] 创建新购物车，项目数:', localItems.length);

      await db.collection('cart').add({
        data: {
          openid: openid,
          items: localItems,
          updateTime: db.serverDate(),
          createTime: db.serverDate()
        }
      });
    }

    console.log('[login] 购物车同步完成');
    return true;
  } catch (error) {
    console.error('[login] 同步购物车失败:', error);
    return false;
  }
}

/**
 * 合并购物车商品
 * @param {Array} cloudItems - 云端购物车商品
 * @param {Array} localItems - 本地购物车商品
 * @returns {Array} 合并后的商品
 */
function mergeCartItems(cloudItems, localItems) {
  // 创建ID映射
  const itemMap = {};

  // 先添加云端商品
  cloudItems.forEach(item => {
    if (item && item.id) {
      itemMap[item.id] = item;
    }
  });

  // 添加或覆盖本地商品
  localItems.forEach(item => {
    if (item && item.id) {
      if (itemMap[item.id]) {
        // 同一商品，合并数量，以本地为准
        itemMap[item.id] = item;
      } else {
        // 新商品，直接添加
        itemMap[item.id] = item;
      }
    }
  });

  // 转换回数组
  return Object.values(itemMap);
} 